# $ANTLR 3.1 Gencfa.g 2008-09-30 02:21:11

import sys
from antlr3 import *
from antlr3.compat import set, frozenset


# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

# token types
STAR=21
RULE=19
TARGETALPHA=36
TARGETHUE=33
TARGETSATURATION=34
MOD=11
STARTSHAPE=13
USER_RATIONAL_TARGET=32
XSHIFT=24
RIGHTBRACKET=17
BG=7
USER_STRING=14
WHITESPACE=39
TARGETBRIGHTNESS=35
ROTATE=22
EOF=-1
SATURATION=29
STATEMENT=5
ALPHA=31
NAME=8
BACKGROUND=15
CFGD=4
LEFTBRACE=37
USER_RATIONAL=20
REPLACEMENT=9
ZSHIFT=26
BRIGHTNESS=30
LOOP=10
SKEW=27
FLIP=23
RIGHTBRACE=38
HUE=28
ADJ=12
INIT=6
SIZE=18
LEFTBRACKET=16
YSHIFT=25


class GencfaLexer(Lexer):

    grammarFileName = "Gencfa.g"
    antlr_version = version_str_to_tuple("3.1")
    antlr_version_str = "3.1"

    def __init__(self, input=None, state=None):
        if state is None:
            state = RecognizerSharedState()
        Lexer.__init__(self, input, state)

        self.dfa18 = self.DFA18(
            self, 18,
            eot = self.DFA18_eot,
            eof = self.DFA18_eof,
            min = self.DFA18_min,
            max = self.DFA18_max,
            accept = self.DFA18_accept,
            special = self.DFA18_special,
            transition = self.DFA18_transition
            )






    # $ANTLR start "STARTSHAPE"
    def mSTARTSHAPE(self, ):

        try:
            _type = STARTSHAPE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:134:2: ( 'startshape' )
            # Gencfa.g:134:4: 'startshape'
            pass 
            self.match("startshape")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "STARTSHAPE"



    # $ANTLR start "BACKGROUND"
    def mBACKGROUND(self, ):

        try:
            _type = BACKGROUND
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:136:2: ( 'background' )
            # Gencfa.g:136:5: 'background'
            pass 
            self.match("background")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "BACKGROUND"



    # $ANTLR start "RULE"
    def mRULE(self, ):

        try:
            _type = RULE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:138:6: ( 'rule' )
            # Gencfa.g:138:8: 'rule'
            pass 
            self.match("rule")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RULE"



    # $ANTLR start "LEFTBRACKET"
    def mLEFTBRACKET(self, ):

        try:
            _type = LEFTBRACKET
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:141:2: ( '{' )
            # Gencfa.g:141:4: '{'
            pass 
            self.match(123)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "LEFTBRACKET"



    # $ANTLR start "RIGHTBRACKET"
    def mRIGHTBRACKET(self, ):

        try:
            _type = RIGHTBRACKET
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:144:2: ( '}' )
            # Gencfa.g:144:4: '}'
            pass 
            self.match(125)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RIGHTBRACKET"



    # $ANTLR start "LEFTBRACE"
    def mLEFTBRACE(self, ):

        try:
            _type = LEFTBRACE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:146:2: ( '[' )
            # Gencfa.g:146:4: '['
            pass 
            self.match(91)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "LEFTBRACE"



    # $ANTLR start "RIGHTBRACE"
    def mRIGHTBRACE(self, ):

        try:
            _type = RIGHTBRACE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:148:2: ( ']' )
            # Gencfa.g:148:4: ']'
            pass 
            self.match(93)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RIGHTBRACE"



    # $ANTLR start "STAR"
    def mSTAR(self, ):

        try:
            _type = STAR
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:149:6: ( '*' )
            # Gencfa.g:149:8: '*'
            pass 
            self.match(42)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "STAR"



    # $ANTLR start "XSHIFT"
    def mXSHIFT(self, ):

        try:
            _type = XSHIFT
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:150:8: ( 'x' )
            # Gencfa.g:150:10: 'x'
            pass 
            self.match(120)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "XSHIFT"



    # $ANTLR start "YSHIFT"
    def mYSHIFT(self, ):

        try:
            _type = YSHIFT
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:151:8: ( 'y' )
            # Gencfa.g:151:10: 'y'
            pass 
            self.match(121)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "YSHIFT"



    # $ANTLR start "ZSHIFT"
    def mZSHIFT(self, ):

        try:
            _type = ZSHIFT
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:152:8: ( 'z' )
            # Gencfa.g:152:10: 'z'
            pass 
            self.match(122)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ZSHIFT"



    # $ANTLR start "SIZE"
    def mSIZE(self, ):

        try:
            _type = SIZE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:154:2: ( 's' | 'size' )
            alt1 = 2
            LA1_0 = self.input.LA(1)

            if (LA1_0 == 115) :
                LA1_1 = self.input.LA(2)

                if (LA1_1 == 105) :
                    alt1 = 2
                else:
                    alt1 = 1
            else:
                nvae = NoViableAltException("", 1, 0, self.input)

                raise nvae

            if alt1 == 1:
                # Gencfa.g:154:4: 's'
                pass 
                self.match(115)


            elif alt1 == 2:
                # Gencfa.g:154:10: 'size'
                pass 
                self.match("size")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SIZE"



    # $ANTLR start "ROTATE"
    def mROTATE(self, ):

        try:
            _type = ROTATE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:156:2: ( 'r' | 'rotate' )
            alt2 = 2
            LA2_0 = self.input.LA(1)

            if (LA2_0 == 114) :
                LA2_1 = self.input.LA(2)

                if (LA2_1 == 111) :
                    alt2 = 2
                else:
                    alt2 = 1
            else:
                nvae = NoViableAltException("", 2, 0, self.input)

                raise nvae

            if alt2 == 1:
                # Gencfa.g:156:4: 'r'
                pass 
                self.match(114)


            elif alt2 == 2:
                # Gencfa.g:156:10: 'rotate'
                pass 
                self.match("rotate")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ROTATE"



    # $ANTLR start "BRIGHTNESS"
    def mBRIGHTNESS(self, ):

        try:
            _type = BRIGHTNESS
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:158:2: ( 'b' | 'brightness' )
            alt3 = 2
            LA3_0 = self.input.LA(1)

            if (LA3_0 == 98) :
                LA3_1 = self.input.LA(2)

                if (LA3_1 == 114) :
                    alt3 = 2
                else:
                    alt3 = 1
            else:
                nvae = NoViableAltException("", 3, 0, self.input)

                raise nvae

            if alt3 == 1:
                # Gencfa.g:158:4: 'b'
                pass 
                self.match(98)


            elif alt3 == 2:
                # Gencfa.g:158:10: 'brightness'
                pass 
                self.match("brightness")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "BRIGHTNESS"



    # $ANTLR start "HUE"
    def mHUE(self, ):

        try:
            _type = HUE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:160:2: ( 'h' | 'hue' )
            alt4 = 2
            LA4_0 = self.input.LA(1)

            if (LA4_0 == 104) :
                LA4_1 = self.input.LA(2)

                if (LA4_1 == 117) :
                    alt4 = 2
                else:
                    alt4 = 1
            else:
                nvae = NoViableAltException("", 4, 0, self.input)

                raise nvae

            if alt4 == 1:
                # Gencfa.g:160:4: 'h'
                pass 
                self.match(104)


            elif alt4 == 2:
                # Gencfa.g:160:10: 'hue'
                pass 
                self.match("hue")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "HUE"



    # $ANTLR start "SATURATION"
    def mSATURATION(self, ):

        try:
            _type = SATURATION
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:162:2: ( 'sat' | 'saturation' )
            alt5 = 2
            LA5_0 = self.input.LA(1)

            if (LA5_0 == 115) :
                LA5_1 = self.input.LA(2)

                if (LA5_1 == 97) :
                    LA5_2 = self.input.LA(3)

                    if (LA5_2 == 116) :
                        LA5_3 = self.input.LA(4)

                        if (LA5_3 == 117) :
                            alt5 = 2
                        else:
                            alt5 = 1
                    else:
                        nvae = NoViableAltException("", 5, 2, self.input)

                        raise nvae

                else:
                    nvae = NoViableAltException("", 5, 1, self.input)

                    raise nvae

            else:
                nvae = NoViableAltException("", 5, 0, self.input)

                raise nvae

            if alt5 == 1:
                # Gencfa.g:162:4: 'sat'
                pass 
                self.match("sat")


            elif alt5 == 2:
                # Gencfa.g:162:12: 'saturation'
                pass 
                self.match("saturation")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SATURATION"



    # $ANTLR start "FLIP"
    def mFLIP(self, ):

        try:
            _type = FLIP
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:164:2: ( 'f' | 'flip' )
            alt6 = 2
            LA6_0 = self.input.LA(1)

            if (LA6_0 == 102) :
                LA6_1 = self.input.LA(2)

                if (LA6_1 == 108) :
                    alt6 = 2
                else:
                    alt6 = 1
            else:
                nvae = NoViableAltException("", 6, 0, self.input)

                raise nvae

            if alt6 == 1:
                # Gencfa.g:164:4: 'f'
                pass 
                self.match(102)


            elif alt6 == 2:
                # Gencfa.g:164:10: 'flip'
                pass 
                self.match("flip")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "FLIP"



    # $ANTLR start "SKEW"
    def mSKEW(self, ):

        try:
            _type = SKEW
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:166:2: ( 'skew' )
            # Gencfa.g:166:4: 'skew'
            pass 
            self.match("skew")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SKEW"



    # $ANTLR start "ALPHA"
    def mALPHA(self, ):

        try:
            _type = ALPHA
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:168:2: ( 'a' | 'alpha' )
            alt7 = 2
            LA7_0 = self.input.LA(1)

            if (LA7_0 == 97) :
                LA7_1 = self.input.LA(2)

                if (LA7_1 == 108) :
                    alt7 = 2
                else:
                    alt7 = 1
            else:
                nvae = NoViableAltException("", 7, 0, self.input)

                raise nvae

            if alt7 == 1:
                # Gencfa.g:168:4: 'a'
                pass 
                self.match(97)


            elif alt7 == 2:
                # Gencfa.g:168:10: 'alpha'
                pass 
                self.match("alpha")


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ALPHA"



    # $ANTLR start "TARGETHUE"
    def mTARGETHUE(self, ):

        try:
            _type = TARGETHUE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:170:2: ( '|hue' )
            # Gencfa.g:170:4: '|hue'
            pass 
            self.match("|hue")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TARGETHUE"



    # $ANTLR start "TARGETSATURATION"
    def mTARGETSATURATION(self, ):

        try:
            _type = TARGETSATURATION
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:172:2: ( '|sat' )
            # Gencfa.g:172:4: '|sat'
            pass 
            self.match("|sat")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TARGETSATURATION"



    # $ANTLR start "TARGETBRIGHTNESS"
    def mTARGETBRIGHTNESS(self, ):

        try:
            _type = TARGETBRIGHTNESS
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:174:2: ( '|brightness' )
            # Gencfa.g:174:4: '|brightness'
            pass 
            self.match("|brightness")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TARGETBRIGHTNESS"



    # $ANTLR start "TARGETALPHA"
    def mTARGETALPHA(self, ):

        try:
            _type = TARGETALPHA
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:176:2: ( '|alpha' )
            # Gencfa.g:176:4: '|alpha'
            pass 
            self.match("|alpha")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TARGETALPHA"



    # $ANTLR start "USER_STRING"
    def mUSER_STRING(self, ):

        try:
            _type = USER_STRING
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:181:2: ( ( 'a' .. 'z' | 'A' .. 'Z' )+ )
            # Gencfa.g:181:4: ( 'a' .. 'z' | 'A' .. 'Z' )+
            pass 
            # Gencfa.g:181:4: ( 'a' .. 'z' | 'A' .. 'Z' )+
            cnt8 = 0
            while True: #loop8
                alt8 = 2
                LA8_0 = self.input.LA(1)

                if ((65 <= LA8_0 <= 90) or (97 <= LA8_0 <= 122)) :
                    alt8 = 1


                if alt8 == 1:
                    # Gencfa.g:
                    pass 
                    if (65 <= self.input.LA(1) <= 90) or (97 <= self.input.LA(1) <= 122):
                        self.input.consume()
                    else:
                        mse = MismatchedSetException(None, self.input)
                        self.recover(mse)
                        raise mse



                else:
                    if cnt8 >= 1:
                        break #loop8

                    eee = EarlyExitException(8, self.input)
                    raise eee

                cnt8 += 1





            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "USER_STRING"



    # $ANTLR start "WHITESPACE"
    def mWHITESPACE(self, ):

        try:
            _type = WHITESPACE
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:183:2: ( ( ' ' | '\\n' | '\\t' | '\\r' | '\\f' )+ )
            # Gencfa.g:183:4: ( ' ' | '\\n' | '\\t' | '\\r' | '\\f' )+
            pass 
            # Gencfa.g:183:4: ( ' ' | '\\n' | '\\t' | '\\r' | '\\f' )+
            cnt9 = 0
            while True: #loop9
                alt9 = 2
                LA9_0 = self.input.LA(1)

                if ((9 <= LA9_0 <= 10) or (12 <= LA9_0 <= 13) or LA9_0 == 32) :
                    alt9 = 1


                if alt9 == 1:
                    # Gencfa.g:
                    pass 
                    if (9 <= self.input.LA(1) <= 10) or (12 <= self.input.LA(1) <= 13) or self.input.LA(1) == 32:
                        self.input.consume()
                    else:
                        mse = MismatchedSetException(None, self.input)
                        self.recover(mse)
                        raise mse



                else:
                    if cnt9 >= 1:
                        break #loop9

                    eee = EarlyExitException(9, self.input)
                    raise eee

                cnt9 += 1


            #action start
            _channel = HIDDEN;
            #action end



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "WHITESPACE"



    # $ANTLR start "USER_RATIONAL"
    def mUSER_RATIONAL(self, ):

        try:
            _type = USER_RATIONAL
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:189:2: ( ( '-' )? ( '0' .. '9' )+ | ( '-' )? '0' .. '9' '.' ( '0' .. '9' )* )
            alt14 = 2
            LA14_0 = self.input.LA(1)

            if (LA14_0 == 45) :
                LA14_1 = self.input.LA(2)

                if ((48 <= LA14_1 <= 57)) :
                    LA14_2 = self.input.LA(3)

                    if (LA14_2 == 46) :
                        alt14 = 2
                    else:
                        alt14 = 1
                else:
                    nvae = NoViableAltException("", 14, 1, self.input)

                    raise nvae

            elif ((48 <= LA14_0 <= 57)) :
                LA14_2 = self.input.LA(2)

                if (LA14_2 == 46) :
                    alt14 = 2
                else:
                    alt14 = 1
            else:
                nvae = NoViableAltException("", 14, 0, self.input)

                raise nvae

            if alt14 == 1:
                # Gencfa.g:189:5: ( '-' )? ( '0' .. '9' )+
                pass 
                # Gencfa.g:189:5: ( '-' )?
                alt10 = 2
                LA10_0 = self.input.LA(1)

                if (LA10_0 == 45) :
                    alt10 = 1
                if alt10 == 1:
                    # Gencfa.g:189:5: '-'
                    pass 
                    self.match(45)



                # Gencfa.g:189:10: ( '0' .. '9' )+
                cnt11 = 0
                while True: #loop11
                    alt11 = 2
                    LA11_0 = self.input.LA(1)

                    if ((48 <= LA11_0 <= 57)) :
                        alt11 = 1


                    if alt11 == 1:
                        # Gencfa.g:189:10: '0' .. '9'
                        pass 
                        self.matchRange(48, 57)


                    else:
                        if cnt11 >= 1:
                            break #loop11

                        eee = EarlyExitException(11, self.input)
                        raise eee

                    cnt11 += 1




            elif alt14 == 2:
                # Gencfa.g:190:5: ( '-' )? '0' .. '9' '.' ( '0' .. '9' )*
                pass 
                # Gencfa.g:190:5: ( '-' )?
                alt12 = 2
                LA12_0 = self.input.LA(1)

                if (LA12_0 == 45) :
                    alt12 = 1
                if alt12 == 1:
                    # Gencfa.g:190:5: '-'
                    pass 
                    self.match(45)



                self.matchRange(48, 57)
                self.match(46)
                # Gencfa.g:190:23: ( '0' .. '9' )*
                while True: #loop13
                    alt13 = 2
                    LA13_0 = self.input.LA(1)

                    if ((48 <= LA13_0 <= 57)) :
                        alt13 = 1


                    if alt13 == 1:
                        # Gencfa.g:190:24: '0' .. '9'
                        pass 
                        self.matchRange(48, 57)


                    else:
                        break #loop13




            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "USER_RATIONAL"



    # $ANTLR start "USER_RATIONAL_TARGET"
    def mUSER_RATIONAL_TARGET(self, ):

        try:
            _type = USER_RATIONAL_TARGET
            _channel = DEFAULT_CHANNEL

            # Gencfa.g:194:2: ( ( '0' .. '9' )+ '|' | '-' ( '0' .. '9' )+ '|' )
            alt17 = 2
            LA17_0 = self.input.LA(1)

            if ((48 <= LA17_0 <= 57)) :
                alt17 = 1
            elif (LA17_0 == 45) :
                alt17 = 2
            else:
                nvae = NoViableAltException("", 17, 0, self.input)

                raise nvae

            if alt17 == 1:
                # Gencfa.g:194:4: ( '0' .. '9' )+ '|'
                pass 
                # Gencfa.g:194:4: ( '0' .. '9' )+
                cnt15 = 0
                while True: #loop15
                    alt15 = 2
                    LA15_0 = self.input.LA(1)

                    if ((48 <= LA15_0 <= 57)) :
                        alt15 = 1


                    if alt15 == 1:
                        # Gencfa.g:194:4: '0' .. '9'
                        pass 
                        self.matchRange(48, 57)


                    else:
                        if cnt15 >= 1:
                            break #loop15

                        eee = EarlyExitException(15, self.input)
                        raise eee

                    cnt15 += 1


                self.match(124)


            elif alt17 == 2:
                # Gencfa.g:195:4: '-' ( '0' .. '9' )+ '|'
                pass 
                self.match(45)
                # Gencfa.g:195:7: ( '0' .. '9' )+
                cnt16 = 0
                while True: #loop16
                    alt16 = 2
                    LA16_0 = self.input.LA(1)

                    if ((48 <= LA16_0 <= 57)) :
                        alt16 = 1


                    if alt16 == 1:
                        # Gencfa.g:195:7: '0' .. '9'
                        pass 
                        self.matchRange(48, 57)


                    else:
                        if cnt16 >= 1:
                            break #loop16

                        eee = EarlyExitException(16, self.input)
                        raise eee

                    cnt16 += 1


                self.match(124)


            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "USER_RATIONAL_TARGET"



    def mTokens(self):
        # Gencfa.g:1:8: ( STARTSHAPE | BACKGROUND | RULE | LEFTBRACKET | RIGHTBRACKET | LEFTBRACE | RIGHTBRACE | STAR | XSHIFT | YSHIFT | ZSHIFT | SIZE | ROTATE | BRIGHTNESS | HUE | SATURATION | FLIP | SKEW | ALPHA | TARGETHUE | TARGETSATURATION | TARGETBRIGHTNESS | TARGETALPHA | USER_STRING | WHITESPACE | USER_RATIONAL | USER_RATIONAL_TARGET )
        alt18 = 27
        alt18 = self.dfa18.predict(self.input)
        if alt18 == 1:
            # Gencfa.g:1:10: STARTSHAPE
            pass 
            self.mSTARTSHAPE()


        elif alt18 == 2:
            # Gencfa.g:1:21: BACKGROUND
            pass 
            self.mBACKGROUND()


        elif alt18 == 3:
            # Gencfa.g:1:32: RULE
            pass 
            self.mRULE()


        elif alt18 == 4:
            # Gencfa.g:1:37: LEFTBRACKET
            pass 
            self.mLEFTBRACKET()


        elif alt18 == 5:
            # Gencfa.g:1:49: RIGHTBRACKET
            pass 
            self.mRIGHTBRACKET()


        elif alt18 == 6:
            # Gencfa.g:1:62: LEFTBRACE
            pass 
            self.mLEFTBRACE()


        elif alt18 == 7:
            # Gencfa.g:1:72: RIGHTBRACE
            pass 
            self.mRIGHTBRACE()


        elif alt18 == 8:
            # Gencfa.g:1:83: STAR
            pass 
            self.mSTAR()


        elif alt18 == 9:
            # Gencfa.g:1:88: XSHIFT
            pass 
            self.mXSHIFT()


        elif alt18 == 10:
            # Gencfa.g:1:95: YSHIFT
            pass 
            self.mYSHIFT()


        elif alt18 == 11:
            # Gencfa.g:1:102: ZSHIFT
            pass 
            self.mZSHIFT()


        elif alt18 == 12:
            # Gencfa.g:1:109: SIZE
            pass 
            self.mSIZE()


        elif alt18 == 13:
            # Gencfa.g:1:114: ROTATE
            pass 
            self.mROTATE()


        elif alt18 == 14:
            # Gencfa.g:1:121: BRIGHTNESS
            pass 
            self.mBRIGHTNESS()


        elif alt18 == 15:
            # Gencfa.g:1:132: HUE
            pass 
            self.mHUE()


        elif alt18 == 16:
            # Gencfa.g:1:136: SATURATION
            pass 
            self.mSATURATION()


        elif alt18 == 17:
            # Gencfa.g:1:147: FLIP
            pass 
            self.mFLIP()


        elif alt18 == 18:
            # Gencfa.g:1:152: SKEW
            pass 
            self.mSKEW()


        elif alt18 == 19:
            # Gencfa.g:1:157: ALPHA
            pass 
            self.mALPHA()


        elif alt18 == 20:
            # Gencfa.g:1:163: TARGETHUE
            pass 
            self.mTARGETHUE()


        elif alt18 == 21:
            # Gencfa.g:1:173: TARGETSATURATION
            pass 
            self.mTARGETSATURATION()


        elif alt18 == 22:
            # Gencfa.g:1:190: TARGETBRIGHTNESS
            pass 
            self.mTARGETBRIGHTNESS()


        elif alt18 == 23:
            # Gencfa.g:1:207: TARGETALPHA
            pass 
            self.mTARGETALPHA()


        elif alt18 == 24:
            # Gencfa.g:1:219: USER_STRING
            pass 
            self.mUSER_STRING()


        elif alt18 == 25:
            # Gencfa.g:1:231: WHITESPACE
            pass 
            self.mWHITESPACE()


        elif alt18 == 26:
            # Gencfa.g:1:242: USER_RATIONAL
            pass 
            self.mUSER_RATIONAL()


        elif alt18 == 27:
            # Gencfa.g:1:256: USER_RATIONAL_TARGET
            pass 
            self.mUSER_RATIONAL_TARGET()







    # lookup tables for DFA #18

    DFA18_eot = DFA.unpack(
        u"\1\uffff\1\30\1\33\1\36\5\uffff\1\37\1\40\1\41\1\43\1\45\1\47"
        u"\4\uffff\1\55\4\20\1\uffff\2\20\1\uffff\2\20\4\uffff\1\20\1\uffff"
        u"\1\20\1\uffff\1\20\5\uffff\1\55\2\uffff\1\55\2\20\1\77\5\20\1\43"
        u"\2\20\1\55\1\20\1\30\1\20\1\uffff\1\111\2\20\1\114\1\20\1\45\3"
        u"\20\1\uffff\2\20\1\uffff\1\20\1\47\4\20\1\36\14\20\1\144\1\77\1"
        u"\145\1\33\2\uffff"
        )

    DFA18_eof = DFA.unpack(
        u"\146\uffff"
        )

    DFA18_min = DFA.unpack(
        u"\1\11\3\101\5\uffff\6\101\1\141\2\uffff\2\60\1\141\1\172\1\164"
        u"\1\145\1\uffff\1\143\1\151\1\uffff\1\154\1\164\4\uffff\1\145\1"
        u"\uffff\1\151\1\uffff\1\160\5\uffff\1\60\2\uffff\1\60\1\162\1\145"
        u"\1\101\1\167\1\153\1\147\1\145\1\141\1\101\1\160\1\150\1\60\1\164"
        u"\1\101\1\162\1\uffff\1\101\1\147\1\150\1\101\1\164\1\101\1\141"
        u"\1\163\1\141\1\uffff\1\162\1\164\1\uffff\1\145\1\101\1\150\1\164"
        u"\1\157\1\156\1\101\1\141\1\151\1\165\1\145\1\160\1\157\1\156\1"
        u"\163\1\145\1\156\1\144\1\163\4\101\2\uffff"
        )

    DFA18_max = DFA.unpack(
        u"\1\175\3\172\5\uffff\6\172\1\163\2\uffff\1\71\1\174\1\141\1\172"
        u"\1\164\1\145\1\uffff\1\143\1\151\1\uffff\1\154\1\164\4\uffff\1"
        u"\145\1\uffff\1\151\1\uffff\1\160\5\uffff\1\174\2\uffff\1\174\1"
        u"\162\1\145\1\172\1\167\1\153\1\147\1\145\1\141\1\172\1\160\1\150"
        u"\1\174\1\164\1\172\1\162\1\uffff\1\172\1\147\1\150\1\172\1\164"
        u"\1\172\1\141\1\163\1\141\1\uffff\1\162\1\164\1\uffff\1\145\1\172"
        u"\1\150\1\164\1\157\1\156\1\172\1\141\1\151\1\165\1\145\1\160\1"
        u"\157\1\156\1\163\1\145\1\156\1\144\1\163\4\172\2\uffff"
        )

    DFA18_accept = DFA.unpack(
        u"\4\uffff\1\4\1\5\1\6\1\7\1\10\7\uffff\1\30\1\31\6\uffff\1\14\2"
        u"\uffff\1\16\2\uffff\1\15\1\11\1\12\1\13\1\uffff\1\17\1\uffff\1"
        u"\21\1\uffff\1\23\1\24\1\25\1\26\1\27\1\uffff\1\32\1\33\20\uffff"
        u"\1\20\11\uffff\1\22\2\uffff\1\3\27\uffff\1\1\1\2"
        )

    DFA18_special = DFA.unpack(
        u"\146\uffff"
        )

            
    DFA18_transition = [
        DFA.unpack(u"\2\21\1\uffff\2\21\22\uffff\1\21\11\uffff\1\10\2\uffff"
        u"\1\22\2\uffff\12\23\7\uffff\32\20\1\6\1\uffff\1\7\3\uffff\1\16"
        u"\1\2\3\20\1\15\1\20\1\14\11\20\1\3\1\1\4\20\1\11\1\12\1\13\1\4"
        u"\1\17\1\5"),
        DFA.unpack(u"\32\20\6\uffff\1\26\7\20\1\25\1\20\1\27\10\20\1\24"
        u"\6\20"),
        DFA.unpack(u"\32\20\6\uffff\1\31\20\20\1\32\10\20"),
        DFA.unpack(u"\32\20\6\uffff\16\20\1\35\5\20\1\34\5\20"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\24\20\1\42\5\20"),
        DFA.unpack(u"\32\20\6\uffff\13\20\1\44\16\20"),
        DFA.unpack(u"\32\20\6\uffff\13\20\1\46\16\20"),
        DFA.unpack(u"\1\53\1\52\5\uffff\1\50\12\uffff\1\51"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\12\54"),
        DFA.unpack(u"\12\57\102\uffff\1\56"),
        DFA.unpack(u"\1\60"),
        DFA.unpack(u"\1\61"),
        DFA.unpack(u"\1\62"),
        DFA.unpack(u"\1\63"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\64"),
        DFA.unpack(u"\1\65"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\66"),
        DFA.unpack(u"\1\67"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\1\70"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\71"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\72"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\12\73\102\uffff\1\56"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\12\57\102\uffff\1\56"),
        DFA.unpack(u"\1\74"),
        DFA.unpack(u"\1\75"),
        DFA.unpack(u"\32\20\6\uffff\24\20\1\76\5\20"),
        DFA.unpack(u"\1\100"),
        DFA.unpack(u"\1\101"),
        DFA.unpack(u"\1\102"),
        DFA.unpack(u"\1\103"),
        DFA.unpack(u"\1\104"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\105"),
        DFA.unpack(u"\1\106"),
        DFA.unpack(u"\12\73\102\uffff\1\56"),
        DFA.unpack(u"\1\107"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\110"),
        DFA.unpack(u""),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\112"),
        DFA.unpack(u"\1\113"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\115"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\116"),
        DFA.unpack(u"\1\117"),
        DFA.unpack(u"\1\120"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\121"),
        DFA.unpack(u"\1\122"),
        DFA.unpack(u""),
        DFA.unpack(u"\1\123"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\124"),
        DFA.unpack(u"\1\125"),
        DFA.unpack(u"\1\126"),
        DFA.unpack(u"\1\127"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\1\130"),
        DFA.unpack(u"\1\131"),
        DFA.unpack(u"\1\132"),
        DFA.unpack(u"\1\133"),
        DFA.unpack(u"\1\134"),
        DFA.unpack(u"\1\135"),
        DFA.unpack(u"\1\136"),
        DFA.unpack(u"\1\137"),
        DFA.unpack(u"\1\140"),
        DFA.unpack(u"\1\141"),
        DFA.unpack(u"\1\142"),
        DFA.unpack(u"\1\143"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u"\32\20\6\uffff\32\20"),
        DFA.unpack(u""),
        DFA.unpack(u"")
    ]

    # class definition for DFA #18

    DFA18 = DFA
 



def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
    from antlr3.main import LexerMain
    main = LexerMain(GencfaLexer)
    main.stdin = stdin
    main.stdout = stdout
    main.stderr = stderr
    main.execute(argv)


if __name__ == '__main__':
    main(sys.argv)
